#!/usr/bin/python

import re
import os
from DAC.DBA.dbmanager import DBInterface
from xml.etree.ElementTree import parse
from xml.etree.ElementTree import ElementTree
from xml.etree.ElementTree import Element
from DAC.MesureDAC import Mesure
from DAC.ConfigWifiDAC import ConfigWifi
from DAC.ListWifiDAC import ListWifi
from DAC.PerfWifiDAC import PerfWifi

class exportXML():
    """ Classe permettant d'exporter les donnees de la campagne en XML
    """
    def __init__(self,filename):
        """ Constructeur
        @param filename emplacement complet du fichier d'export
        """
        #Racine de notre fichier XML
        self.racine=Element("Resultats")
        #Fichier de sortie XML
        self.filename=filename
        #Initialisation des dictionnaires
        self.dicobatiment={}
        self.dicosalle={}
        self.dicoaccesspoint={}
        self.dicocampagne={}
        expr=re.compile('[a-zA-Z]')   
        fichier=open(os.path.expanduser('~') + '/.GWA/dicobatiment','r')
        for line in fichier.readlines():
            if expr.findall(line):
                self.dicobatiment[line.split(':')[0].split('\n')[0]]=line.split(':')[1].split('\n')[0]
        fichier.close()
        fichier=open(os.path.expanduser('~') + '/.GWA/dicocampagne','r')
        for line in fichier.readlines():
            if expr.findall(line):
                self.dicocampagne[line.split(':')[0].split('\n')[0]]=line.split(':')[1].split('\n')[0]
        fichier.close()
        fichier=open(os.path.expanduser('~') + '/.GWA/dicoaccesspoint','r')
        for line in fichier.readlines():
            if expr.findall(line):
                self.dicoaccesspoint[line.split(':')[0].split('\n')[0]]=line.split(':')[1].split('\n')[0]
        fichier.close()
        fichier=open(os.path.expanduser('~') + '/.GWA/dicosalle','r')
        for line in fichier.readlines():
            if expr.findall(line):
                self.dicosalle[line.split(':')[0].split('\n')[0]]=line.split(':')[1].split('\n')[0]
        fichier.close()
        #Valeur de l ID de la campagne, sevira pour recuperation des mesures dans la BDD
        self.ca_id=''

    def indent(self,elem, level=0):
        """ Fonction d'indentation du XML (recuperee sur le net)
        """
        i = "\n" + level*"  "
        if len(elem):
            if not elem.text or not elem.text.strip():
                elem.text = i + "  "
            if not elem.tail or not elem.tail.strip():
                elem.tail = i
            for child in elem:
                self.indent(child, level+1)
            if not child.tail or not child.tail.strip():
                child.tail = i
            if not elem.tail or not elem.tail.strip():
                elem.tail = i
        else:
            if level and (not elem.tail or not elem.tail.strip()):
                elem.tail = i


    def fromSalle(self):
        """" Recuperation des infos de la salle
        """
        racine_salle = Element("Salle")
        #Filtre pour recuperer que les elements necessaires depuis le dico
        filtre=['id','nom','description','x','y','z','realwidth','realheight']
        #On collecte les donnees
        for key in filtre:
                 salle_attrib = Element(key)
                 salle_attrib.text = str(self.dicosalle[key])
                 racine_salle.append(salle_attrib)
        self.racine.append(racine_salle)

    def fromBatiment(self):
        """" Recuperation des infos du batiment
        """
        racine_batiment = Element("Batiment")
        #Filtre pour recuperer que les elements necessaires depuis le dico
        filtre=['id','nom','x','y','realwidth','realheight']
        #On collecte les donnees
        for key in filtre:
                 batiment_attrib = Element(key)
                 batiment_attrib.text = str(self.dicobatiment[key])
                 racine_batiment.append(batiment_attrib)
        self.racine.append(racine_batiment)

    def fromCampagne(self):
        """" Recuperation des infos de la campagne
        """
        racine_campagne = Element("Campagne")
        #On collecte toutes les donnees
        for key in self.dicocampagne:
                 campagne_attrib = Element(key)
                 campagne_attrib.text = str(self.dicocampagne[key])
                 racine_campagne.append(campagne_attrib)
                 #On sauvegarde l ID de la campagne, ca nous servira pour plus tard
                 if (key == 'id'):
                     self.ca_id=self.dicocampagne[key]
        self.racine.append(racine_campagne)

    def fromMesures(self):
        """" Recuperation des infos mesures
        """
        racine_mesure = Element("Mesures")
        #Initilisation vers la BDD
        mesures = Mesure()
        config = ConfigWifi()
        liste_cellules = ListWifi()
        iperf = PerfWifi()
        #Recupration des mesures pour la campagne
        liste_mesures = mesures.selectMesureFromDB(self.ca_id);
        #On ne garde que ce qui est important
        filtre=['x','y','z','description']
        #On parcours toutes les mesures
        for mesure in liste_mesures:
            #Definition d'une branche XML
            numero_mesure=Element(mesure['ID'])
            #On ne prends que les elements voulus
            for key in filtre:
                #Definition et remplissage d'une feuille XML
                mesure_attrib = Element(str(key))
                mesure_attrib.text = str(mesure[key])
                #On connecte notre feuille a la branche
                numero_mesure.append(mesure_attrib)
            #On recupere la configuration WiFi au moment de la mesure
            detailsmesure=config.selectConfigWifiFromDB(mesure['ID'])[0]
            #On parse les resultats
            for configuration in detailsmesure.keys():
                #Les ID sont inutiles
                if (configuration != "link_me" and configuration != "ID"):
                    #Comme avant on defini et on rempli une feuille XML
                    mesure_attrib = Element(str(configuration))
                    mesure_attrib.text = str(detailsmesure[configuration])
                    #Feuille qui sera accrochee a la branche <mesure> correspondante
                    numero_mesure.append(mesure_attrib)
            #On recupere les debits mesures
            debits=iperf.selectPerfWifiFromDB(mesure['ID'])
            #On parcours la liste
            for liste_debits_mesure in debits:
                numero_debit= Element("Debit")
                #On parcours les resultats
                for debit_mesure in liste_debits_mesure.keys():
                    #Identifiants inutiles
                    if (debit_mesure != "ID"):
                        #Definition et remplissage de la feuille
                        debit_attrib = Element(str(debit_mesure))
                        debit_attrib.text = str(liste_debits_mesure[debit_mesure]) 
                        #Feuille qui sera accrochee a la branche <debit> correspondante
                        numero_debit.append(debit_attrib)
                #On raccroche la branche debit a la branche mesure
                numero_mesure.append(numero_debit)
            #On recupere la liste des AP au moment de la mesure
            autres_ap=liste_cellules.selectListWifiFromDB(mesure['ID'])
            #On parcours la liste
            for liste_autres_ap in autres_ap:
                numero_ap= Element("AP")
                #On parcours les resultats
                for autre_ap in liste_autres_ap.keys():
                    #Identifiant inutile
                    if (autre_ap != "ID"):
                        #Definition et remplissage de la feuille
                        ap_attrib = Element(str(autre_ap))
                        ap_attrib.text = str(liste_autres_ap[autre_ap]) 
                        #Feuille qui sera accrochee a la branche <AP> correspondante
                        numero_ap.append(ap_attrib)
                #On raccroche la branche AP a la branche mesure
                numero_mesure.append(numero_ap)
            #et On ajoute tout ca a notre racine Mesure
            racine_mesure.append(numero_mesure)
        #On rajoute ca a notre arbre xml principal
        self.racine.append(racine_mesure)
                
    def writeXML(self):
        """" Ecriture du fichier
        """
        self.fromBatiment()
        self.fromSalle()
        self.fromCampagne()
        self.fromMesures()
        Xmltree=ElementTree(self.racine)
        self.indent(Xmltree.getroot())
        Xmltree.write(self.filename)        